let CAV: any = {
	FRONT: 0,
	BACK: 1,
	DOUBLE: 2,
	SVGNS: 'http://www.w3.org/2000/svg',
	Array: typeof Float32Array === 'function' ? Float32Array : Array,
	Utils: {
		isNumber: function (a: any) {
			return !isNaN(parseFloat(a)) && isFinite(a);
		},
	},
};
(function () {
	for (
		var a = 0, b = ['ms', 'moz', 'webkit', 'o'], c = 0;
		c < b.length && !window.requestAnimationFrame;
		++c
	)
		(window.requestAnimationFrame = (window as any)[b[c] + 'RequestAnimationFrame']),
			(window.cancelAnimationFrame =
				(window as any)[b[c] + 'CancelAnimationFrame'] ||
				(window as any)[b[c] + 'CancelRequestAnimationFrame']);
	if (!window.requestAnimationFrame)
		window.requestAnimationFrame = function (b) {
			var c = new Date().getTime(),
				f = Math.max(0, 16 - (c - a)),
				g = window.setTimeout(function () {
					b(c + f);
				}, f);
			a = c + f;
			return g;
		};
	if (!window.cancelAnimationFrame)
		window.cancelAnimationFrame = function (a) {
			clearTimeout(a);
		};
})();

const randomInRange = function (a: number, b: number) {
	return a + (b - a) * Math.random();
};
const clamp = function (a: number, b: number, c: number) {
	a = Math.max(a, b);
	return (a = Math.min(a, c));
};

CAV.Vector3 = {
	create: function (a: any, b: any, c: any) {
		var d = new CAV.Array(3);
		this.set(d, a, b, c);
		return d;
	},
	clone: function (a: any) {
		var b = this.create();
		this.copy(b, a);
		return b;
	},
	set: function (a: any[], b: number, c: number, d: number) {
		a[0] = b || 0;
		a[1] = c || 0;
		a[2] = d || 0;
		return this;
	},
	setX: function (a: any[], b: number) {
		a[0] = b || 0;
		return this;
	},
	setY: function (a: any[], b: number) {
		a[1] = b || 0;
		return this;
	},
	setZ: function (a: any[], b: number) {
		a[2] = b || 0;
		return this;
	},
	copy: function (a: any[], b: any[]) {
		a[0] = b[0];
		a[1] = b[1];
		a[2] = b[2];
		return this;
	},
	add: function (a: any[], b: any[]) {
		a[0] += b[0];
		a[1] += b[1];
		a[2] += b[2];
		return this;
	},
	addVectors: function (a: any[], b: any[], c: any[]) {
		a[0] = b[0] + c[0];
		a[1] = b[1] + c[1];
		a[2] = b[2] + c[2];
		return this;
	},
	addScalar: function (a: any[], b: any) {
		a[0] += b;
		a[1] += b;
		a[2] += b;
		return this;
	},
	subtract: function (a: number[], b: number[]) {
		a[0] -= b[0];
		a[1] -= b[1];
		a[2] -= b[2];
		return this;
	},
	subtractVectors: function (a: number[], b: number[], c: number[]) {
		a[0] = b[0] - c[0];
		a[1] = b[1] - c[1];
		a[2] = b[2] - c[2];
		return this;
	},
	subtractScalar: function (a: number[], b: number) {
		a[0] -= b;
		a[1] -= b;
		a[2] -= b;
		return this;
	},
	multiply: function (a: number[], b: number[]) {
		a[0] *= b[0];
		a[1] *= b[1];
		a[2] *= b[2];
		return this;
	},
	multiplyVectors: function (a: number[], b: number[], c: number[]) {
		a[0] = b[0] * c[0];
		a[1] = b[1] * c[1];
		a[2] = b[2] * c[2];
		return this;
	},
	multiplyScalar: function (a: number[], b: number) {
		a[0] *= b;
		a[1] *= b;
		a[2] *= b;
		return this;
	},
	divide: function (a: number[], b: number[]) {
		a[0] /= b[0];
		a[1] /= b[1];
		a[2] /= b[2];
		return this;
	},
	divideVectors: function (a: number[], b: number[], c: number[]) {
		a[0] = b[0] / c[0];
		a[1] = b[1] / c[1];
		a[2] = b[2] / c[2];
		return this;
	},
	divideScalar: function (a: number[], b: number) {
		b !== 0 ? ((a[0] /= b), (a[1] /= b), (a[2] /= b)) : ((a[0] = 0), (a[1] = 0), (a[2] = 0));
		return this;
	},
	cross: function (a: number[], b: number[]) {
		var c = a[0],
			d = a[1],
			e = a[2];
		a[0] = d * b[2] - e * b[1];
		a[1] = e * b[0] - c * b[2];
		a[2] = c * b[1] - d * b[0];
		return this;
	},
	crossVectors: function (a: number[], b: number[], c: number[]) {
		a[0] = b[1] * c[2] - b[2] * c[1];
		a[1] = b[2] * c[0] - b[0] * c[2];
		a[2] = b[0] * c[1] - b[1] * c[0];
		return this;
	},
	min: function (a: any[], b: number) {
		a[0] < b && (a[0] = b);
		a[1] < b && (a[1] = b);
		a[2] < b && (a[2] = b);
		return this;
	},
	max: function (a: any[], b: number) {
		a[0] > b && (a[0] = b);
		a[1] > b && (a[1] = b);
		a[2] > b && (a[2] = b);
		return this;
	},
	clamp: function (a: any, b: any, c: any) {
		this.min(a, b);
		this.max(a, c);
		return this;
	},
	limit: function (a: any, b: number | null, c: number | null) {
		var d = this.length(a);
		b !== null && d < b ? this.setLength(a, b) : c !== null && d > c && this.setLength(a, c);
		return this;
	},
	dot: function (a: number[], b: number[]) {
		return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
	},
	normalise: function (a: any) {
		return this.divideScalar(a, this.length(a));
	},
	negate: function (a: any) {
		return this.multiplyScalar(a, -1);
	},
	distanceSquared: function (a: number[], b: number[]) {
		var c = a[0] - b[0],
			d = a[1] - b[1],
			e = a[2] - b[2];
		return c * c + d * d + e * e;
	},
	distance: function (a: any, b: any) {
		return Math.sqrt(this.distanceSquared(a, b));
	},
	lengthSquared: function (a: number[]) {
		return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
	},
	length: function (a: any) {
		return Math.sqrt(this.lengthSquared(a));
	},
	setLength: function (a: any, b: number) {
		var c = this.length(a);
		c !== 0 && b !== c && this.multiplyScalar(a, b / c);
		return this;
	},
};
CAV.Vector4 = {
	create: function (a: any, b: any, c: any) {
		var d = new CAV.Array(4);
		this.set(d, a, b, c);
		return d;
	},
	set: function (a: any[], b: number, c: number, d: number, e: number) {
		a[0] = b || 0;
		a[1] = c || 0;
		a[2] = d || 0;
		a[3] = e || 0;
		return this;
	},
	setX: function (a: any[], b: number) {
		a[0] = b || 0;
		return this;
	},
	setY: function (a: any[], b: number) {
		a[1] = b || 0;
		return this;
	},
	setZ: function (a: any[], b: number) {
		a[2] = b || 0;
		return this;
	},
	setW: function (a: any[], b: number) {
		a[3] = b || 0;
		return this;
	},
	add: function (a: any[], b: any[]) {
		a[0] += b[0];
		a[1] += b[1];
		a[2] += b[2];
		a[3] += b[3];
		return this;
	},
	multiplyVectors: function (a: number[], b: number[], c: number[]) {
		a[0] = b[0] * c[0];
		a[1] = b[1] * c[1];
		a[2] = b[2] * c[2];
		a[3] = b[3] * c[3];
		return this;
	},
	multiplyScalar: function (a: number[], b: number) {
		a[0] *= b;
		a[1] *= b;
		a[2] *= b;
		a[3] *= b;
		return this;
	},
	min: function (a: any[], b: number) {
		a[0] < b && (a[0] = b);
		a[1] < b && (a[1] = b);
		a[2] < b && (a[2] = b);
		a[3] < b && (a[3] = b);
		return this;
	},
	max: function (a: any[], b: number) {
		a[0] > b && (a[0] = b);
		a[1] > b && (a[1] = b);
		a[2] > b && (a[2] = b);
		a[3] > b && (a[3] = b);
		return this;
	},
	clamp: function (a: any, b: any, c: any) {
		this.min(a, b);
		this.max(a, c);
		return this;
	},
};
CAV.Color = function (a: string, b: any) {
	this.rgba = CAV.Vector4.create();
	this.hex = a || '#000000';
	this.opacity = CAV.Utils.isNumber(b) ? b : 1;
	this.set(this.hex, this.opacity);
};
CAV.Color.prototype = {
	set: function (a: string, b: any) {
		var a = a.replace('#', ''),
			c = a.length / 3;
		this.rgba[0] = parseInt(a.substring(c * 0, c * 1), 16) / 255;
		this.rgba[1] = parseInt(a.substring(c * 1, c * 2), 16) / 255;
		this.rgba[2] = parseInt(a.substring(c * 2, c * 3), 16) / 255;
		this.rgba[3] = CAV.Utils.isNumber(b) ? b : this.rgba[3];
		return this;
	},
	hexify: function (a: string | number) {
		a = Math.ceil(Number(a) * 255).toString(16);
		a.length === 1 && (a = '0' + a);
		return a;
	},
	format: function () {
		var a = this.hexify(this.rgba[0]),
			b = this.hexify(this.rgba[1]),
			c = this.hexify(this.rgba[2]);
		return (this.hex = '#' + a + b + c);
	},
};
CAV.Object = function () {
	this.position = CAV.Vector3.create();
};
CAV.Object.prototype = {
	setPosition: function (a: any, b: any, c: any) {
		CAV.Vector3.set(this.position, a, b, c);
		return this;
	},
};
CAV.Light = function (a: any, b: any) {
	CAV.Object.call(this);
	this.ambient = new CAV.Color(a || '#FFFFFF');
	this.diffuse = new CAV.Color(b || '#FFFFFF');
	this.ray = CAV.Vector3.create();
};
CAV.Light.prototype = Object.create(CAV.Object.prototype);
CAV.Vertex = function (a: any, b: any, c: any) {
	this.position = CAV.Vector3.create(a, b, c);
};
CAV.Vertex.prototype = {
	setPosition: function (a: any, b: any, c: any) {
		CAV.Vector3.set(this.position, a, b, c);
		return this;
	},
};
CAV.Triangle = function (a: any, b: any, c: any) {
	this.a = a || new CAV.Vertex();
	this.b = b || new CAV.Vertex();
	this.c = c || new CAV.Vertex();
	this.vertices = [this.a, this.b, this.c];
	this.u = CAV.Vector3.create();
	this.v = CAV.Vector3.create();
	this.centroid = CAV.Vector3.create();
	this.normal = CAV.Vector3.create();
	this.color = new CAV.Color();
	this.polygon = document.createElementNS(CAV.SVGNS, 'polygon');
	this.polygon.setAttributeNS(null, 'stroke-linejoin', 'round');
	this.polygon.setAttributeNS(null, 'stroke-miterlimit', '1');
	this.polygon.setAttributeNS(null, 'stroke-width', '1');
	this.computeCentroid();
	this.computeNormal();
};
CAV.Triangle.prototype = {
	computeCentroid: function () {
		this.centroid[0] = this.a.position[0] + this.b.position[0] + this.c.position[0];
		this.centroid[1] = this.a.position[1] + this.b.position[1] + this.c.position[1];
		this.centroid[2] = this.a.position[2] + this.b.position[2] + this.c.position[2];
		CAV.Vector3.divideScalar(this.centroid, 3);
		return this;
	},
	computeNormal: function () {
		CAV.Vector3.subtractVectors(this.u, this.b.position, this.a.position);
		CAV.Vector3.subtractVectors(this.v, this.c.position, this.a.position);
		CAV.Vector3.crossVectors(this.normal, this.u, this.v);
		CAV.Vector3.normalise(this.normal);
		return this;
	},
};
CAV.Geometry = function () {
	this.vertices = [];
	this.triangles = [];
	this.dirty = false;
};
CAV.Geometry.prototype = {
	update: function () {
		if (this.dirty) {
			var a, b;
			for (a = this.triangles.length - 1; a >= 0; a--)
				(b = this.triangles[a]), b.computeCentroid(), b.computeNormal();
			this.dirty = false;
		}
		return this;
	},
};
CAV.Plane = function (a: number, b: number, _c: number, d: number) {
	let t0, t1;
	CAV.Geometry.call(this);
	this.width = a || 100;
	this.height = b || 100;
	this.segments = _c || 4;
	this.slices = d || 4;
	this.segmentWidth = this.width / this.segments;
	this.sliceHeight = this.height / this.slices;
	var e,
		f,
		g,
		c = [];
	e = this.width * -0.5;
	f = this.height * 0.5;
	for (a = 0; a <= this.segments; a++) {
		c.push([]);
		for (b = 0; b <= this.slices; b++)
			(d = new CAV.Vertex(e + a * this.segmentWidth, f - b * this.sliceHeight)),
				(c[a] as Array<any>).push(d),
				this.vertices.push(d);
	}
	for (a = 0; a < this.segments; a++)
		for (b = 0; b < this.slices; b++)
			(d = c[a + 0][b + 0]),
				(e = c[a + 0][b + 1]),
				(f = c[a + 1][b + 0]),
				(g = c[a + 1][b + 1]),
				(t0 = new CAV.Triangle(d, e, f)),
				(t1 = new CAV.Triangle(f, e, g)),
				this.triangles.push(t0, t1);
};
CAV.Plane.prototype = Object.create(CAV.Geometry.prototype);
CAV.Material = function (a: any, b: any) {
	this.ambient = new CAV.Color(a || '#444444');
	this.diffuse = new CAV.Color(b || '#FFFFFF');
	this.slave = new CAV.Color();
};
CAV.Mesh = function (a: any, b: any) {
	CAV.Object.call(this);
	this.geometry = a || new CAV.Geometry();
	this.material = b || new CAV.Material();
	this.side = CAV.FRONT;
	this.visible = true;
};
CAV.Mesh.prototype = Object.create(CAV.Object.prototype);
CAV.Mesh.prototype.update = function (a: string | any[], b: any) {
	var c, d, e, f, g;
	this.geometry.update();
	if (b)
		for (c = this.geometry.triangles.length - 1; c >= 0; c--) {
			d = this.geometry.triangles[c];
			CAV.Vector4.set(d.color.rgba);
			for (e = a.length - 1; e >= 0; e--)
				(f = a[e]),
					CAV.Vector3.subtractVectors(f.ray, f.position, d.centroid),
					CAV.Vector3.normalise(f.ray),
					(g = CAV.Vector3.dot(d.normal, f.ray)),
					this.side === CAV.FRONT
						? (g = Math.max(g, 0))
						: this.side === CAV.BACK
						? (g = Math.abs(Math.min(g, 0)))
						: this.side === CAV.DOUBLE && (g = Math.max(Math.abs(g), 0)),
					CAV.Vector4.multiplyVectors(
						this.material.slave.rgba,
						this.material.ambient.rgba,
						f.ambient.rgba
					),
					CAV.Vector4.add(d.color.rgba, this.material.slave.rgba),
					CAV.Vector4.multiplyVectors(
						this.material.slave.rgba,
						this.material.diffuse.rgba,
						f.diffuse.rgba
					),
					CAV.Vector4.multiplyScalar(this.material.slave.rgba, g),
					CAV.Vector4.add(d.color.rgba, this.material.slave.rgba);
			CAV.Vector4.clamp(d.color.rgba, 0, 1);
		}
	return this;
};
CAV.Scene = function () {
	this.meshes = [];
	this.lights = [];
};
CAV.Scene.prototype = {
	add: function (a: any) {
		a instanceof CAV.Mesh && !~this.meshes.indexOf(a)
			? this.meshes.push(a)
			: a instanceof CAV.Light && !~this.lights.indexOf(a) && this.lights.push(a);
		return this;
	},
	remove: function (a: any) {
		a instanceof CAV.Mesh && ~this.meshes.indexOf(a)
			? this.meshes.splice(this.meshes.indexOf(a), 1)
			: a instanceof CAV.Light &&
			  ~this.lights.indexOf(a) &&
			  this.lights.splice(this.lights.indexOf(a), 1);
		return this;
	},
};
CAV.Renderer = function () {
	this.halfHeight = this.halfWidth = this.height = this.width = 0;
};
CAV.Renderer.prototype = {
	setSize: function (a: any, b: any) {
		if (!(this.width === a && this.height === b))
			return (
				(this.width = a),
				(this.height = b),
				(this.halfWidth = this.width * 0.5),
				(this.halfHeight = this.height * 0.5),
				this
			);
	},
	clear: function () {
		return this;
	},
	render: function () {
		return this;
	},
};
CAV.CanvasRenderer = function () {
	CAV.Renderer.call(this);
	this.element = document.createElement('canvas');
	this.element.style.display = 'block';
	this.element.style.position = 'absolute';
	this.element.style.left = '0';
	this.element.style.top = '0';
	this.context = this.element.getContext('2d');
	this.setSize(this.element.width, this.element.height);
};
CAV.CanvasRenderer.prototype = Object.create(CAV.Renderer.prototype);
CAV.CanvasRenderer.prototype.setSize = function (a: any, b: any) {
	CAV.Renderer.prototype.setSize.call(this, a, b);
	this.element.width = a;
	this.element.height = b;
	this.context.setTransform(1, 0, 0, -1, this.halfWidth, this.halfHeight);
	return this;
};
CAV.CanvasRenderer.prototype.clear = function () {
	CAV.Renderer.prototype.clear.call(this);
	this.context.clearRect(-this.halfWidth, -this.halfHeight, this.width, this.height);
	return this;
};
CAV.CanvasRenderer.prototype.render = function (a: { meshes: string | any[]; lights: any }) {
	CAV.Renderer.prototype.render.call(this, a);
	var b, c, d, e, f;
	this.clear();
	this.context.lineJoin = 'round';
	this.context.lineWidth = 1;
	for (b = a.meshes.length - 1; b >= 0; b--)
		if (((c = a.meshes[b]), c.visible)) {
			c.update(a.lights, true);
			for (d = c.geometry.triangles.length - 1; d >= 0; d--)
				(e = c.geometry.triangles[d]),
					(f = e.color.format()),
					this.context.beginPath(),
					this.context.moveTo(e.a.position[0], e.a.position[1]),
					this.context.lineTo(e.b.position[0], e.b.position[1]),
					this.context.lineTo(e.c.position[0], e.c.position[1]),
					this.context.closePath(),
					(this.context.strokeStyle = f),
					(this.context.fillStyle = f),
					this.context.stroke(),
					this.context.fill();
		}
	return this;
};

export function Victor(container: string, anitOut: string) {
	let J, l;

	if (!!document.createElement('canvas').getContext) {
		var t = {
			width: 1.5,
			height: 1.5,
			depth: 10,
			segments: 12,
			slices: 6,
			xRange: 0.8,
			yRange: 0.1,
			zRange: 1,
			ambient: '#525252',
			diffuse: '#FFFFFF',
			speed: 0.0002,
		};
		var G = {
			count: 2,
			xyScalar: 1,
			zOffset: 100,
			ambient: '#002c4a',
			diffuse: '#005584',
			speed: 0.001,
			gravity: 1200,
			dampening: 0.95,
			minLimit: 10,
			maxLimit: null,
			minDistance: 20,
			maxDistance: 400,
			autopilot: false,
			draw: false,
			bounds: CAV.Vector3.create(),
			step: CAV.Vector3.create(
				randomInRange(0.2, 1),
				randomInRange(0.2, 1),
				randomInRange(0.2, 1)
			),
		};
		var m = 'canvas';
		var E = 'svg';
		var x = {
			renderer: m,
		};
		var i: number,
			n = Date.now();
		var L = CAV.Vector3.create();
		var k = CAV.Vector3.create();
		var z = document.getElementById(container || 'container');
		var w = document.getElementById(anitOut || 'anitOut');
		var D: {
				element: any;
				setSize: (arg0: number, arg1: number) => void;
				clear: () => void;
				width: number;
				height: number;
				halfWidth: any;
				halfHeight: any;
				render: (arg0: any) => void;
			},
			I: { remove: (arg0: any) => void; add: (arg0: any) => void; lights: string | any[] },
			h: any,
			q: {
				vertices: string | any[];
				segmentWidth: number;
				sliceHeight: number;
				dirty: boolean;
			},
			y;
		var g: any;
		var r;

		function C() {
			F();
			p();
			s();
			B();
			v();
			K((z as HTMLElement).offsetWidth, (z as HTMLElement).offsetHeight);
			o();
		}

		function F() {
			g = new CAV.CanvasRenderer();
			H(x.renderer);
		}

		function H(N: string) {
			if (D) {
				(w as HTMLElement).removeChild(D.element);
			}
			switch (N) {
				case m:
					D = g;
					break;
			}
			D.setSize((z as HTMLElement).offsetWidth, (z as HTMLElement).offsetHeight);
			(w as HTMLElement).appendChild(D.element);
		}

		function p() {
			I = new CAV.Scene();
		}

		function s() {
			I.remove(h);
			D.clear();
			q = new CAV.Plane(t.width * D.width, t.height * D.height, t.segments, t.slices);
			y = new CAV.Material(t.ambient, t.diffuse);
			h = new CAV.Mesh(q, y);
			I.add(h);
			var N, O;
			for (N = q.vertices.length - 1; N >= 0; N--) {
				O = q.vertices[N];
				O.anchor = CAV.Vector3.clone(O.position);
				O.step = CAV.Vector3.create(
					randomInRange(0.2, 1),
					randomInRange(0.2, 1),
					randomInRange(0.2, 1)
				);
				O.time = randomInRange(0, Math.PI * 2);
			}
		}

		function B() {
			var O, N;
			for (O = I.lights.length - 1; O >= 0; O--) {
				N = I.lights[O];
				I.remove(N);
			}
			D.clear();
			for (O = 0; O < G.count; O++) {
				N = new CAV.Light(G.ambient, G.diffuse);
				N.ambientHex = N.ambient.format();
				N.diffuseHex = N.diffuse.format();
				I.add(N);
				N.mass = randomInRange(0.5, 1);
				N.velocity = CAV.Vector3.create();
				N.acceleration = CAV.Vector3.create();
				N.force = CAV.Vector3.create();
			}
		}

		function K(O: number, N: number) {
			D.setSize(O, N);
			CAV.Vector3.set(L, D.halfWidth, D.halfHeight);
			s();
		}

		function o() {
			i = Date.now() - n;
			u();
			M();
			requestAnimationFrame(o);
		}

		function u() {
			var Q,
				P,
				O,
				R,
				T,
				V,
				U,
				S = t.depth / 2;
			CAV.Vector3.copy(G.bounds, L);
			CAV.Vector3.multiplyScalar(G.bounds, G.xyScalar);
			CAV.Vector3.setZ(k, G.zOffset);
			for (R = I.lights.length - 1; R >= 0; R--) {
				T = I.lights[R];
				CAV.Vector3.setZ(T.position, G.zOffset);
				var N = clamp(
					CAV.Vector3.distanceSquared(T.position, k),
					G.minDistance,
					G.maxDistance
				);
				var W = (G.gravity * T.mass) / N;
				CAV.Vector3.subtractVectors(T.force, k, T.position);
				CAV.Vector3.normalise(T.force);
				CAV.Vector3.multiplyScalar(T.force, W);
				CAV.Vector3.set(T.acceleration);
				CAV.Vector3.add(T.acceleration, T.force);
				CAV.Vector3.add(T.velocity, T.acceleration);
				CAV.Vector3.multiplyScalar(T.velocity, G.dampening);
				CAV.Vector3.limit(T.velocity, G.minLimit, G.maxLimit);
				CAV.Vector3.add(T.position, T.velocity);
			}
			for (V = q.vertices.length - 1; V >= 0; V--) {
				U = q.vertices[V];
				Q = Math.sin(U.time + U.step[0] * i * t.speed);
				P = Math.cos(U.time + U.step[1] * i * t.speed);
				O = Math.sin(U.time + U.step[2] * i * t.speed);
				CAV.Vector3.set(
					U.position,
					t.xRange * q.segmentWidth * Q,
					t.yRange * q.sliceHeight * P,
					t.zRange * S * O - S
				);
				CAV.Vector3.add(U.position, U.anchor);
			}
			q.dirty = true;
		}

		function M() {
			D.render(I);
		}

		J = (O: any) => {
			var Q,
				N,
				S = O;
			var P = function (T: any) {
				for (Q = 0, l = I.lights.length; Q < l; Q++) {
					N = I.lights[Q];
					N.ambient.set(T);
					N.ambientHex = N.ambient.format();
				}
			};
			var R = function (T: any) {
				for (Q = 0, l = I.lights.length; Q < l; Q++) {
					N = I.lights[Q];
					N.diffuse.set(T);
					N.diffuseHex = N.diffuse.format();
				}
			};
			return {
				set: function () {
					P(S[0]);
					R(S[1]);
				},
			};
		};

		function v() {
			window.addEventListener('resize', j);
		}

		function A(N: { x: any; y: number }) {
			CAV.Vector3.set(k, N.x, D.height - N.y);
			CAV.Vector3.subtract(k, L);
		}

		function j(N: any) {
			K((z as HTMLElement).offsetWidth, (z as HTMLElement).offsetHeight);
			M();
		}
		C();
	}
	return J;
}
